/**
 * @brief	任务处理函数
 * @details	可根据任务的执行顺序分步运行程序
 * @par History:
 *	v1.0: 蔡正祥, 2024-03-04, 初代版本....\n
 *	v1.1: 蔡正祥, 2024-11-13, 改进了一些....\n
 *	v2.0: 蔡正祥, 2024-11-21, 改动很大，重写了代码结构....\n
 */

#include "bsp_Task.h"
#include "User_App.h"

u_Task_t *Task_Buff[TASK_MAX];

/*  @brief  单个任务计时
    @param  *obj
            任务对象
    @return 无
    @property 无
*/
void bsp_Task_Obj_IRQHandler(u_Task_t *obj)
{
    if (obj->t_State == t_RUN)
    {
        if (obj->t_Countdown > 0)
            obj->t_Countdown--;
    }
}
/*  @brief  任务计时
    @return 无
    @property 放在1ms定时器中
*/
void bsp_Task_IRQHandler(void)
{
    for (uint8_t t = 0; t < TASK_MAX; t++)
    {
        if (Task_Buff[t] == NULL)
        {
            return;
        }
        else
        {
            bsp_Task_Obj_IRQHandler(Task_Buff[t]);
        }
    }
}

/*  @brief  新建一个任务
    @param  *obj
            任务对象
    @return 无
    @property 无
*/
u_Task_e bsp_Task_Obj_New(u_Task_t *obj)
{
    for (uint8_t t = 0; t < TASK_MAX; t++)
    {
        if (Task_Buff[t] == NULL)
        {
            Task_Buff[t] = obj;
            return t_OK;
        }
    }
    return t_ERR;
}

/*  @brief  运行任务
    @param  *obj
            任务对象
    @return 无
    @property 无
*/
void bsp_Task_Obj_Set_Run(u_Task_t *obj)
{
    obj->t_State = t_RUN;
    obj->t_Proc = 0;
    obj->t_ErrYard = e_OK;
}
/*  @brief  停止任务
    @param  *obj
            任务对象
    @return 无
    @property 无
*/
void bsp_Task_Obj_Set_Stop(u_Task_t *obj)
{
    obj->t_State = t_STOP;
}
/*  @brief  暂停任务
    @param  *obj
            任务对象
    @return 无
    @property 无
*/
void bsp_Task_Obj_Set_Pause(u_Task_t *obj)
{
    obj->t_State = t_PAUSE;
}
/*  @brief  恢复任务
    @param  *obj
            任务对象
    @return 无
    @property 无
*/
void bsp_Task_Obj_Set_Renew(u_Task_t *obj)
{
    obj->t_State = t_RENEW;
}
/*  @brief  获取任务状态
    @param  *obj
            任务对象
    @return 状态
    @property 无
*/
u_State_e bsp_Task_Obj_Get_State(u_Task_t *obj)
{
    return (obj->t_State);
}
/*  @brief  获取任务进度
    @param  *obj
            任务对象
    @return 进度 高字节代表节点进度，低字节代表子节点进度
    @property 无
*/
uint16_t bsp_Task_Obj_Get_Proc(u_Task_t *obj)
{
    return (obj->t_Proc);
}

/*  @brief  单个任务处理
    @return 无
    @property 无
*/
void bsp_Task_Obj_Handle(u_Task_t *obj)
{
    static uint8_t t_PAUSE_Flag = 0; // 暂停标志 0：等待暂停完成、1：暂停中  防止重复进入暂停或恢复状态
    static uint8_t t_STOP_Flag = 0;  // 停止标志  防止重复进入停止状态
    uint8_t t_Proc_Node = 0;         // 节点任务
    uint8_t t_Proc_Node_s = 0;       // 节点任务-子节点
    u_Task_e returnValue = t_NOK;

    t_Proc_Node = obj->t_Proc >> 8;
    t_Proc_Node_s = obj->t_Proc & 0xFF;

    if (obj->t_State == t_RUN) // 运行：开始、结束
    {
        if (t_Proc_Node_s == U_START)
        {
            obj->t_Countdown = obj->t_TaskNode[t_Proc_Node].ta_TimeOut; // 倒计时赋值

            returnValue = obj->t_TaskNode[t_Proc_Node].u_Task_Handle[U_START].ta_Task_Handle();
            if (returnValue == t_OK)
            {
                t_Proc_Node_s = U_END;
            }
            else if (returnValue == t_ERR)
            {
                obj->t_ErrYard = e_ABNORMAL;
                obj->t_ErrEvent();
                obj->t_State = t_STOP;
                return;
            }
        }
        else if (t_Proc_Node_s == U_END)
        {
            returnValue = obj->t_TaskNode[t_Proc_Node].u_Task_Handle[U_END].ta_Task_Handle();
            if (returnValue == t_OK)
            {
                t_Proc_Node += 1;        // 片段进程+1
                t_Proc_Node_s = U_START; // 为下一个状态进程清零

                if (t_Proc_Node >= obj->t_Num) // 判断任务是否执行结束
                {
                    obj->t_State = t_STOP;
                    obj->t_Proc = 0;
                    return;
                }
            }
            else if (returnValue == t_ERR)
            {
                obj->t_ErrYard = e_ABNORMAL;
                obj->t_ErrEvent();
                obj->t_State = t_STOP;
                return;
            }
        }

        obj->t_Proc = (t_Proc_Node << 8) | t_Proc_Node_s; // 任务进程更新
        t_STOP_Flag = 1;

        if (obj->t_Countdown == 0) // 超时退出
        {
            obj->t_ErrYard = e_TIMEOUT;
            obj->t_ErrEvent();
            obj->t_State = t_STOP;
            return;
        }
    }
    else if (obj->t_State == t_PAUSE) // 暂停
    {
        if (t_PAUSE_Flag == 0)
        {
            returnValue = obj->t_TaskNode[t_Proc_Node].u_Task_Handle[U_PAUSE].ta_Task_Handle();
            if (returnValue == t_OK)
            {
                t_PAUSE_Flag = 1; // 防止反复进入暂停程序，使其处在暂停中的状态
            }
            else if (returnValue == t_ERR)
            {
                obj->t_ErrYard = e_ABNORMAL;
                obj->t_ErrEvent();
                obj->t_State = t_STOP;
                return;
            }
        }
    }
    else if (obj->t_State == t_RENEW) // 恢复
    {
        if (t_PAUSE_Flag == 1)
        {
            returnValue = obj->t_TaskNode[t_Proc_Node].u_Task_Handle[U_RENEW].ta_Task_Handle();
            if (returnValue == t_OK)
            {
                t_PAUSE_Flag = 0;     // 清除暂停标志
                obj->t_State = t_RUN; // 重新设置成运行标志
            }
            else if (returnValue == t_ERR)
            {
                obj->t_ErrYard = e_ABNORMAL;
                obj->t_ErrEvent();
                obj->t_State = t_STOP;
                return;
            }
        }
    }
    else if (obj->t_State == t_STOP) // 停止
    {
        if (t_STOP_Flag == 1)
        {
            obj->t_StopEvent();
            obj->t_Proc = 0;
            obj->t_State = t_STOP;
            t_STOP_Flag = 0;
            return;
        }
    }
}
/*  @brief  任务处理函数
 *  @return 无
 *  @property 放在主函数中处理
 */
void bsp_Task_Handle(void)
{
    for (uint8_t t = 0; t < TASK_MAX; t++)
    {
        if (Task_Buff[t] == NULL)
        {
            return;
        }
        else
        {
            bsp_Task_Obj_Handle(Task_Buff[t]);
        }
    }
}
